home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / kprobes.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  9.4 KB  |  322 lines
  1. #ifndef _LINUX_KPROBES_H
  2. #define _LINUX_KPROBES_H
  3. /*
  4.  *  Kernel Probes (KProbes)
  5.  *  include/linux/kprobes.h
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program; if not, write to the Free Software
  19.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20.  *
  21.  * Copyright (C) IBM Corporation, 2002, 2004
  22.  *
  23.  * 2002-Oct    Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
  24.  *        Probes initial implementation ( includes suggestions from
  25.  *        Rusty Russell).
  26.  * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
  27.  *        interface to access function arguments.
  28.  * 2005-May    Hien Nguyen <hien@us.ibm.com> and Jim Keniston
  29.  *        <jkenisto@us.ibm.com>  and Prasanna S Panchamukhi
  30.  *        <prasanna@in.ibm.com> added function-return probes.
  31.  */
  32. #include <linux/linkage.h>
  33. #include <linux/list.h>
  34. #include <linux/notifier.h>
  35. #include <linux/smp.h>
  36. #include <linux/percpu.h>
  37. #include <linux/spinlock.h>
  38. #include <linux/rcupdate.h>
  39. #include <linux/mutex.h>
  40.  
  41. #ifdef CONFIG_KPROBES
  42. #include <asm/kprobes.h>
  43.  
  44. /* kprobe_status settings */
  45. #define KPROBE_HIT_ACTIVE    0x00000001
  46. #define KPROBE_HIT_SS        0x00000002
  47. #define KPROBE_REENTER        0x00000004
  48. #define KPROBE_HIT_SSDONE    0x00000008
  49.  
  50. /* Attach to insert probes on any functions which should be ignored*/
  51. #define __kprobes    __attribute__((__section__(".kprobes.text"))) notrace
  52.  
  53. struct kprobe;
  54. struct pt_regs;
  55. struct kretprobe;
  56. struct kretprobe_instance;
  57. typedef int (*kprobe_pre_handler_t) (struct kprobe *, struct pt_regs *);
  58. typedef int (*kprobe_break_handler_t) (struct kprobe *, struct pt_regs *);
  59. typedef void (*kprobe_post_handler_t) (struct kprobe *, struct pt_regs *,
  60.                        unsigned long flags);
  61. typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *,
  62.                        int trapnr);
  63. typedef int (*kretprobe_handler_t) (struct kretprobe_instance *,
  64.                     struct pt_regs *);
  65.  
  66. struct kprobe {
  67.     struct hlist_node hlist;
  68.  
  69.     /* list of kprobes for multi-handler support */
  70.     struct list_head list;
  71.  
  72.     /* Indicates that the corresponding module has been ref counted */
  73.     unsigned int mod_refcounted;
  74.  
  75.     /*count the number of times this probe was temporarily disarmed */
  76.     unsigned long nmissed;
  77.  
  78.     /* location of the probe point */
  79.     kprobe_opcode_t *addr;
  80.  
  81.     /* Allow user to indicate symbol name of the probe point */
  82.     const char *symbol_name;
  83.  
  84.     /* Offset into the symbol */
  85.     unsigned int offset;
  86.  
  87.     /* Called before addr is executed. */
  88.     kprobe_pre_handler_t pre_handler;
  89.  
  90.     /* Called after addr is executed, unless... */
  91.     kprobe_post_handler_t post_handler;
  92.  
  93.     /* ... called if executing addr causes a fault (eg. page fault).
  94.      * Return 1 if it handled fault, otherwise kernel will see it. */
  95.     kprobe_fault_handler_t fault_handler;
  96.  
  97.     /* ... called if breakpoint trap occurs in probe handler.
  98.      * Return 1 if it handled break, otherwise kernel will see it. */
  99.     kprobe_break_handler_t break_handler;
  100.  
  101.     /* Saved opcode (which has been replaced with breakpoint) */
  102.     kprobe_opcode_t opcode;
  103.  
  104.     /* copy of the original instruction */
  105.     struct arch_specific_insn ainsn;
  106. };
  107.  
  108. /*
  109.  * Special probe type that uses setjmp-longjmp type tricks to resume
  110.  * execution at a specified entry with a matching prototype corresponding
  111.  * to the probed function - a trick to enable arguments to become
  112.  * accessible seamlessly by probe handling logic.
  113.  * Note:
  114.  * Because of the way compilers allocate stack space for local variables
  115.  * etc upfront, regardless of sub-scopes within a function, this mirroring
  116.  * principle currently works only for probes placed on function entry points.
  117.  */
  118. struct jprobe {
  119.     struct kprobe kp;
  120.     void *entry;    /* probe handling code to jump to */
  121. };
  122.  
  123. /* For backward compatibility with old code using JPROBE_ENTRY() */
  124. #define JPROBE_ENTRY(handler)    (handler)
  125.  
  126. DECLARE_PER_CPU(struct kprobe *, current_kprobe);
  127. DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
  128.  
  129. #ifdef CONFIG_KRETPROBES
  130. extern void arch_prepare_kretprobe(struct kretprobe_instance *ri,
  131.                    struct pt_regs *regs);
  132. extern int arch_trampoline_kprobe(struct kprobe *p);
  133. #else /* CONFIG_KRETPROBES */
  134. static inline void arch_prepare_kretprobe(struct kretprobe *rp,
  135.                     struct pt_regs *regs)
  136. {
  137. }
  138. static inline int arch_trampoline_kprobe(struct kprobe *p)
  139. {
  140.     return 0;
  141. }
  142. #endif /* CONFIG_KRETPROBES */
  143. /*
  144.  * Function-return probe -
  145.  * Note:
  146.  * User needs to provide a handler function, and initialize maxactive.
  147.  * maxactive - The maximum number of instances of the probed function that
  148.  * can be active concurrently.
  149.  * nmissed - tracks the number of times the probed function's return was
  150.  * ignored, due to maxactive being too low.
  151.  *
  152.  */
  153. struct kretprobe {
  154.     struct kprobe kp;
  155.     kretprobe_handler_t handler;
  156.     kretprobe_handler_t entry_handler;
  157.     int maxactive;
  158.     int nmissed;
  159.     size_t data_size;
  160.     struct hlist_head free_instances;
  161.     spinlock_t lock;
  162. };
  163.  
  164. struct kretprobe_instance {
  165.     struct hlist_node hlist;
  166.     struct kretprobe *rp;
  167.     kprobe_opcode_t *ret_addr;
  168.     struct task_struct *task;
  169.     char data[0];
  170. };
  171.  
  172. struct kretprobe_blackpoint {
  173.     const char *name;
  174.     void *addr;
  175. };
  176.  
  177. struct kprobe_blackpoint {
  178.     const char *name;
  179.     unsigned long start_addr;
  180.     unsigned long range;
  181. };
  182.  
  183. extern struct kretprobe_blackpoint kretprobe_blacklist[];
  184.  
  185. static inline void kretprobe_assert(struct kretprobe_instance *ri,
  186.     unsigned long orig_ret_address, unsigned long trampoline_address)
  187. {
  188.     if (!orig_ret_address || (orig_ret_address == trampoline_address)) {
  189.         printk("kretprobe BUG!: Processing kretprobe %p @ %p\n",
  190.                 ri->rp, ri->rp->kp.addr);
  191.         BUG();
  192.     }
  193. }
  194.  
  195. #ifdef CONFIG_KPROBES_SANITY_TEST
  196. extern int init_test_probes(void);
  197. #else
  198. static inline int init_test_probes(void)
  199. {
  200.     return 0;
  201. }
  202. #endif /* CONFIG_KPROBES_SANITY_TEST */
  203.  
  204. extern struct mutex kprobe_mutex;
  205. extern int arch_prepare_kprobe(struct kprobe *p);
  206. extern void arch_arm_kprobe(struct kprobe *p);
  207. extern void arch_disarm_kprobe(struct kprobe *p);
  208. extern int arch_init_kprobes(void);
  209. extern void show_registers(struct pt_regs *regs);
  210. extern kprobe_opcode_t *get_insn_slot(void);
  211. extern void free_insn_slot(kprobe_opcode_t *slot, int dirty);
  212. extern void kprobes_inc_nmissed_count(struct kprobe *p);
  213.  
  214. /* Get the kprobe at this addr (if any) - called with preemption disabled */
  215. struct kprobe *get_kprobe(void *addr);
  216. void kretprobe_hash_lock(struct task_struct *tsk,
  217.              struct hlist_head **head, unsigned long *flags);
  218. void kretprobe_hash_unlock(struct task_struct *tsk, unsigned long *flags);
  219. struct hlist_head * kretprobe_inst_table_head(struct task_struct *tsk);
  220.  
  221. /* kprobe_running() will just return the current_kprobe on this CPU */
  222. static inline struct kprobe *kprobe_running(void)
  223. {
  224.     return (__get_cpu_var(current_kprobe));
  225. }
  226.  
  227. static inline void reset_current_kprobe(void)
  228. {
  229.     __get_cpu_var(current_kprobe) = NULL;
  230. }
  231.  
  232. static inline struct kprobe_ctlblk *get_kprobe_ctlblk(void)
  233. {
  234.     return (&__get_cpu_var(kprobe_ctlblk));
  235. }
  236.  
  237. int register_kprobe(struct kprobe *p);
  238. void unregister_kprobe(struct kprobe *p);
  239. int register_kprobes(struct kprobe **kps, int num);
  240. void unregister_kprobes(struct kprobe **kps, int num);
  241. int setjmp_pre_handler(struct kprobe *, struct pt_regs *);
  242. int longjmp_break_handler(struct kprobe *, struct pt_regs *);
  243. int register_jprobe(struct jprobe *p);
  244. void unregister_jprobe(struct jprobe *p);
  245. int register_jprobes(struct jprobe **jps, int num);
  246. void unregister_jprobes(struct jprobe **jps, int num);
  247. void jprobe_return(void);
  248. unsigned long arch_deref_entry_point(void *);
  249.  
  250. int register_kretprobe(struct kretprobe *rp);
  251. void unregister_kretprobe(struct kretprobe *rp);
  252. int register_kretprobes(struct kretprobe **rps, int num);
  253. void unregister_kretprobes(struct kretprobe **rps, int num);
  254.  
  255. void kprobe_flush_task(struct task_struct *tk);
  256. void recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head);
  257.  
  258. #else /* CONFIG_KPROBES */
  259.  
  260. #define __kprobes    notrace
  261. struct jprobe;
  262. struct kretprobe;
  263.  
  264. static inline struct kprobe *get_kprobe(void *addr)
  265. {
  266.     return NULL;
  267. }
  268. static inline struct kprobe *kprobe_running(void)
  269. {
  270.     return NULL;
  271. }
  272. static inline int register_kprobe(struct kprobe *p)
  273. {
  274.     return -ENOSYS;
  275. }
  276. static inline int register_kprobes(struct kprobe **kps, int num)
  277. {
  278.     return -ENOSYS;
  279. }
  280. static inline void unregister_kprobe(struct kprobe *p)
  281. {
  282. }
  283. static inline void unregister_kprobes(struct kprobe **kps, int num)
  284. {
  285. }
  286. static inline int register_jprobe(struct jprobe *p)
  287. {
  288.     return -ENOSYS;
  289. }
  290. static inline int register_jprobes(struct jprobe **jps, int num)
  291. {
  292.     return -ENOSYS;
  293. }
  294. static inline void unregister_jprobe(struct jprobe *p)
  295. {
  296. }
  297. static inline void unregister_jprobes(struct jprobe **jps, int num)
  298. {
  299. }
  300. static inline void jprobe_return(void)
  301. {
  302. }
  303. static inline int register_kretprobe(struct kretprobe *rp)
  304. {
  305.     return -ENOSYS;
  306. }
  307. static inline int register_kretprobes(struct kretprobe **rps, int num)
  308. {
  309.     return -ENOSYS;
  310. }
  311. static inline void unregister_kretprobe(struct kretprobe *rp)
  312. {
  313. }
  314. static inline void unregister_kretprobes(struct kretprobe **rps, int num)
  315. {
  316. }
  317. static inline void kprobe_flush_task(struct task_struct *tk)
  318. {
  319. }
  320. #endif                /* CONFIG_KPROBES */
  321. #endif                /* _LINUX_KPROBES_H */
  322.